Empiece

Buscar en scripts para "Exponential Moving Average"

EMARCOThis is the study of the ratio of the MACD exponential moving averages, 0.993 and 1.003 were used to define the overextended positions since this is the highest the oscillator usually goes, price tends to reverse when overextended. RE1 (ratio equation 1) = the fast Exponential Moving Average (12 points) divided by the slow Exponential Moving Average (26 points) and RE2 is reciprocal. Here we see that when the RE1 is greater than RE2 price tends to drop and so when the opposite is true
Indicador Pine Script®
por DarkMessiah777
1
Variable Moving Average [LazyBear]Variable Moving Average, often abbreviated as VMA, is an Exponential Moving Average developed by Tushar S. Chande. VMA automatically adjusts its smoothing constant on the basis of Market Volatility. Use this like other Moving Averages. I have added the following options that can be enabled via options page: - Trend Direction Indication: Green = Up trend, Blue = Potential congestion, Red = down trend. - Color bars based on Trend More info: www.thewizardtrader.com List of my other indicators: - GDoc: docs.google.com - Chart:
Indicador Pine Script®
por LazyBear
51
PineStats█ OVERVIEW PineStats is a comprehensive statistical analysis library for Pine Script v6, providing 104 functions across 6 modules. Built for quantitative traders, researchers, and indicator developers who need professional-grade statistics without reinventing the wheel. For building mean-reversion strategies, analyzing return distributions, measuring correlations, or testing for market regimes. █ MODULES CORE STATISTICS (20 functions) • Central tendency: mean, median, WMA, EMA • Dispersion: variance, stdev, MAD, range • Standardization: z-score, robust z-score, normalize, percentile • Distribution shape: skewness, kurtosis PROBABILITY DISTRIBUTIONS (17 functions) • Normal: PDF, CDF, inverse CDF (quantile function) • Power-law: Hill estimator, MLE alpha, survival function • Exponential: PDF, CDF, rate estimation • Normality testing: Jarque-Bera test ENTROPY (9 functions) • Shannon entropy (information theory) • Tsallis entropy (non-extensive, fat-tail sensitive) • Permutation entropy (ordinal patterns) • Approximate entropy (regularity measure) • Entropy-based regime detection PROBABILITY (21 functions) • Win rates and expected value • First passage time estimation • TP/SL probability analysis • Conditional probability and Bayes updates • Streak and drawdown probabilities REGRESSION (19 functions) • Linear regression: slope, intercept, forecast • Goodness of fit: R², adjusted R², standard error • Statistical tests: t-statistic, p-value, significance • Trend analysis: strength, angle, acceleration • Quadratic regression CORRELATION (18 functions) • Pearson, Spearman, Kendall correlation • Covariance, beta, alpha (Jensen's) • Rolling correlation analysis • Autocorrelation and cross-correlation • Information ratio, tracking error █ QUICK START import HenriqueCentieiro/PineStats/1 as stats // Z-score for mean reversion z = stats.zscore(close, 20) // Test if returns are normally distributed returns = (close - close ) / close isGaussian = stats.is_normal(returns, 100, 0.05) // Regression channel = stats.linreg_channel(close, 50, 2.0) // Correlation with benchmark spyReturns = request.security("SPY", timeframe.period, close/close - 1) beta = stats.beta(returns, spyReturns, 60) █ USE CASES ✓ Mean Reversion — z-scores, percentiles, Bollinger-style analysis ✓ Regime Detection — entropy measures, correlation regimes ✓ Risk Analysis — drawdown probability, VaR via quantiles ✓ Strategy Evaluation — expected value, win rates, R:R analysis ✓ Distribution Analysis — normality tests, fat-tail detection ✓ Multi-Asset — beta, alpha, correlation, relative strength █ NOTES • All functions return `na` on invalid inputs • Designed for Pine Script v6 • Fully documented in the library header • Part of the Pine ecosystem: PineStats, PineQuant, PineCriticality, PineWavelet █ REFERENCES • Abramowitz & Stegun — Normal CDF approximation • Acklam's algorithm — Inverse normal CDF • Hill estimator — Power-law tail estimation • Tsallis statistics — Non-extensive entropy Full documentation in the library header. mean(src, length)   Calculates the arithmetic mean (simple moving average) over a lookback period   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Arithmetic mean of the last `length` values, or `na` if inputs invalid wma_custom(src, length)   Calculates weighted moving average with linearly decreasing weights   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Weighted moving average, or `na` if inputs invalid ema_custom(src, length)   Calculates exponential moving average   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Exponential moving average, or `na` if inputs invalid median(src, length)   Calculates the median value over a lookback period   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Median value, or `na` if inputs invalid variance(src, length)   Calculates population variance over a lookback period   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Population variance, or `na` if inputs invalid stdev(src, length)   Calculates population standard deviation over a lookback period   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Population standard deviation, or `na` if inputs invalid mad(src, length)   Calculates Median Absolute Deviation (MAD) - robust dispersion measure   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: MAD value, or `na` if inputs invalid data_range(src, length)   Calculates the range (highest - lowest) over a lookback period   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Range value, or `na` if inputs invalid zscore(src, length)   Calculates z-score (number of standard deviations from mean)   Parameters:      src (float) : Source series      length (simple int) : Lookback period for mean and stdev calculation (must be >= 2)   Returns: Z-score, or `na` if inputs invalid or stdev is zero zscore_robust(src, length)   Calculates robust z-score using median and MAD (resistant to outliers)   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 2)   Returns: Robust z-score, or `na` if inputs invalid or MAD is zero normalize(src, length)   Normalizes value to range using min-max scaling   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Normalized value in , or `na` if inputs invalid or range is zero percentile(src, length)   Calculates percentile rank of current value within lookback window   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Percentile rank (0 to 100), or `na` if inputs invalid winsorize(src, length, lower_pct, upper_pct)   Winsorizes values by clamping to percentile bounds (reduces outlier impact)   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)      lower_pct (simple float) : Lower percentile bound (0-100, e.g., 5 for 5th percentile)      upper_pct (simple float) : Upper percentile bound (0-100, e.g., 95 for 95th percentile)   Returns: Winsorized value clamped to bounds skewness(src, length)   Calculates sample skewness (measure of distribution asymmetry)   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 3)   Returns: Skewness value (negative = left tail, positive = right tail), or `na` if invalid kurtosis(src, length)   Calculates excess kurtosis (measure of distribution tail heaviness)   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 4)   Returns: Excess kurtosis (>0 = heavy tails, <0 = light tails), or `na` if invalid count_valid(src, length)   Counts non-na values in lookback window (useful for data quality checks)   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Count of valid (non-na) values sum(src, length)   Calculates sum over lookback period   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 1)   Returns: Sum of values, or `na` if inputs invalid cumsum(src)   Calculates cumulative sum (running total from first bar)   Parameters:      src (float) : Source series   Returns: Cumulative sum change(src, length)   Returns the change (difference) from n bars ago   Parameters:      src (float) : Source series      length (simple int) : Number of bars to look back (must be >= 1)   Returns: Current value minus value from `length` bars ago roc(src, length)   Calculates Rate of Change (percentage change from n bars ago)   Parameters:      src (float) : Source series      length (simple int) : Number of bars to look back (must be >= 1)   Returns: Percentage change as decimal (0.05 = 5%), or `na` if invalid normal_pdf_standard(x)   Calculates the standard normal probability density function (PDF)   Parameters:      x (float) : The value to evaluate   Returns: PDF value at x for standard normal N(0,1) normal_pdf(x, mu, sigma)   Calculates the normal probability density function (PDF)   Parameters:      x (float) : The value to evaluate      mu (float) : Mean of the distribution (default: 0)      sigma (float) : Standard deviation (default: 1, must be > 0)   Returns: PDF value at x for normal N(mu, sigma²) normal_cdf_standard(x)   Calculates the standard normal cumulative distribution function (CDF)   Parameters:      x (float) : The value to evaluate   Returns: Probability P(X <= x) for standard normal N(0,1) @description Uses Abramowitz & Stegun approximation (formula 7.1.26), accurate to ~1.5e-7 normal_cdf(x, mu, sigma)   Calculates the normal cumulative distribution function (CDF)   Parameters:      x (float) : The value to evaluate      mu (float) : Mean of the distribution (default: 0)      sigma (float) : Standard deviation (default: 1, must be > 0)   Returns: Probability P(X <= x) for normal N(mu, sigma²) normal_inv_standard(p)   Calculates the inverse standard normal CDF (quantile function)   Parameters:      p (float) : Probability value (must be in (0, 1))   Returns: x such that P(X <= x) = p for standard normal N(0,1) @description Uses Acklam's algorithm, accurate to ~1.15e-9 normal_inv(p, mu, sigma)   Calculates the inverse normal CDF (quantile function)   Parameters:      p (float) : Probability value (must be in (0, 1))      mu (float) : Mean of the distribution      sigma (float) : Standard deviation (must be > 0)   Returns: x such that P(X <= x) = p for normal N(mu, sigma²) power_law_alpha(src, length, tail_pct)   Estimates power-law exponent (alpha) using Hill estimator   Parameters:      src (float) : Source series (typically absolute returns or drawdowns)      length (simple int) : Lookback period (must be >= 10 for reliable estimates)      tail_pct (simple float) : Percentage of data to use for tail estimation (default: 0.1 = top 10%)   Returns: Estimated alpha (tail index), typically 2-4 for financial data @description Alpha < 2 indicates infinite variance (very heavy tails) @description Alpha < 3 indicates infinite kurtosis @description Alpha > 4 suggests near-Gaussian behavior power_law_alpha_mle(src, length, x_min)   Estimates power-law alpha using maximum likelihood (Clauset method)   Parameters:      src (float) : Source series (positive values expected)      length (simple int) : Lookback period (must be >= 20)      x_min (float) : Minimum threshold for power-law behavior   Returns: Estimated alpha using MLE power_law_pdf(x, alpha, x_min)   Calculates power-law probability density (Pareto Type I)   Parameters:      x (float) : Value to evaluate (must be >= x_min)      alpha (float) : Power-law exponent (must be > 1)      x_min (float) : Minimum value / scale parameter (must be > 0)   Returns: PDF value power_law_survival(x, alpha, x_min)   Calculates power-law survival function P(X > x)   Parameters:      x (float) : Value to evaluate (must be >= x_min)      alpha (float) : Power-law exponent (must be > 1)      x_min (float) : Minimum value / scale parameter (must be > 0)   Returns: Probability of exceeding x power_law_ks(src, length, alpha, x_min)   Tests if data follows power-law using simplified Kolmogorov-Smirnov   Parameters:      src (float) : Source series      length (simple int) : Lookback period      alpha (float) : Estimated alpha from power_law_alpha()      x_min (float) : Threshold value   Returns: KS statistic (lower = better fit, typically < 0.1 for good fit) is_power_law(src, length, tail_pct, ks_threshold)   Simple test if distribution appears to follow power-law   Parameters:      src (float) : Source series      length (simple int) : Lookback period      tail_pct (simple float) : Tail percentage for alpha estimation      ks_threshold (simple float) : Maximum KS statistic for acceptance (default: 0.1)   Returns: true if KS test suggests power-law fit exp_pdf(x, lambda)   Calculates exponential probability density function   Parameters:      x (float) : Value to evaluate (must be >= 0)      lambda (float) : Rate parameter (must be > 0)   Returns: PDF value exp_cdf(x, lambda)   Calculates exponential cumulative distribution function   Parameters:      x (float) : Value to evaluate (must be >= 0)      lambda (float) : Rate parameter (must be > 0)   Returns: Probability P(X <= x) exp_lambda(src, length)   Estimates exponential rate parameter (lambda) using MLE   Parameters:      src (float) : Source series (positive values)      length (simple int) : Lookback period   Returns: Estimated lambda (1/mean) jarque_bera(src, length)   Calculates Jarque-Bera test statistic for normality   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 10)   Returns: JB statistic (higher = more deviation from normality) @description Under normality, JB ~ chi-squared(2). JB > 6 suggests non-normality at 5% level is_normal(src, length, significance)   Tests if distribution is approximately normal   Parameters:      src (float) : Source series      length (simple int) : Lookback period      significance (simple float) : Significance level (default: 0.05)   Returns: true if Jarque-Bera test does not reject normality shannon_entropy(src, length, n_bins)   Calculates Shannon entropy from a probability distribution   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 10)      n_bins (simple int) : Number of histogram bins for discretization (default: 10)   Returns: Shannon entropy in bits (log base 2) @description Higher entropy = more randomness/uncertainty, lower = more predictability shannon_entropy_norm(src, length, n_bins)   Calculates normalized Shannon entropy   Parameters:      src (float) : Source series      length (simple int) : Lookback period      n_bins (simple int) : Number of histogram bins   Returns: Normalized entropy where 0 = perfectly predictable, 1 = maximum randomness tsallis_entropy(src, length, q, n_bins)   Calculates Tsallis entropy with q-parameter   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 10)      q (float) : Entropic index (q=1 recovers Shannon entropy)      n_bins (simple int) : Number of histogram bins   Returns: Tsallis entropy value @description q < 1: emphasizes rare events (fat tails) @description q = 1: equivalent to Shannon entropy @description q > 1: emphasizes common events optimal_q(src, length)   Estimates optimal q parameter from kurtosis   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Estimated q value that best captures the distribution's tail behavior @description Uses relationship: q ≈ (5 + kurtosis) / (3 + kurtosis) for kurtosis > 0 tsallis_q_gaussian(x, q, beta)   Calculates Tsallis q-Gaussian probability density   Parameters:      x (float) : Value to evaluate      q (float) : Tsallis q parameter (must be < 3)      beta (float) : Width parameter (inverse temperature, must be > 0)   Returns: q-Gaussian PDF value @description q=1 recovers standard Gaussian permutation_entropy(src, length, order)   Calculates permutation entropy (ordinal pattern complexity)   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 20)      order (simple int) : Embedding dimension / pattern length (2-5, default: 3)   Returns: Normalized permutation entropy @description Measures complexity of temporal ordering patterns @description 0 = perfectly predictable sequence, 1 = random approx_entropy(src, length, m, r)   Calculates Approximate Entropy (ApEn) - regularity measure   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 50)      m (simple int) : Embedding dimension (default: 2)      r (simple float) : Tolerance as fraction of stdev (default: 0.2)   Returns: Approximate entropy value (higher = more irregular/complex) @description Lower ApEn indicates more self-similarity and predictability entropy_regime(src, length, q, n_bins)   Detects market regime based on entropy level   Parameters:      src (float) : Source series (typically returns)      length (simple int) : Lookback period      q (float) : Tsallis q parameter (use optimal_q() or default 1.5)      n_bins (simple int) : Number of histogram bins   Returns: Regime indicator: -1 = trending (low entropy), 0 = transition, 1 = ranging (high entropy) entropy_risk(src, length)   Calculates entropy-based risk indicator   Parameters:      src (float) : Source series (typically returns)      length (simple int) : Lookback period   Returns: Risk score where 1 = maximum divergence from Gaussian 1 hit_rate(src, length)   Calculates hit rate (probability of positive outcome) over lookback   Parameters:      src (float) : Source series (positive values count as hits)      length (simple int) : Lookback period   Returns: Hit rate as decimal hit_rate_cond(condition, length)   Calculates hit rate for custom condition over lookback   Parameters:      condition (bool) : Boolean series (true = hit)      length (simple int) : Lookback period   Returns: Hit rate as decimal expected_value(src, length)   Calculates expected value of a series   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Expected value (mean) expected_value_trade(win_prob, take_profit, stop_loss)   Calculates expected value for a trade with TP and SL levels   Parameters:      win_prob (float) : Probability of hitting TP (0-1)      take_profit (float) : Take profit in price units or %      stop_loss (float) : Stop loss in price units or % (positive value)   Returns: Expected value per trade @description EV = (win_prob * TP) - ((1 - win_prob) * SL) breakeven_winrate(take_profit, stop_loss)   Calculates breakeven win rate for given TP/SL ratio   Parameters:      take_profit (float) : Take profit distance      stop_loss (float) : Stop loss distance   Returns: Required win rate for breakeven (EV = 0) reward_risk_ratio(take_profit, stop_loss)   Calculates the reward-to-risk ratio   Parameters:      take_profit (float) : Take profit distance      stop_loss (float) : Stop loss distance   Returns: R:R ratio fpt_probability(src, length, target, max_bars)   Estimates probability of price reaching target within N bars   Parameters:      src (float) : Source series (typically returns)      length (simple int) : Lookback for volatility estimation      target (float) : Target move (in same units as src, e.g., % return)      max_bars (simple int) : Maximum bars to consider   Returns: Probability of reaching target within max_bars @description Based on random walk with drift approximation fpt_mean(src, length, target)   Estimates mean first passage time to target level   Parameters:      src (float) : Source series (typically returns)      length (simple int) : Lookback for volatility estimation      target (float) : Target move   Returns: Expected number of bars to reach target (can be infinite) fpt_historical(src, length, target)   Counts historical bars to reach target from each point   Parameters:      src (float) : Source series (typically price or returns)      length (simple int) : Lookback period      target (float) : Target move from each starting point   Returns: Array of first passage times (na if target not reached within lookback) tp_probability(src, length, tp_distance, sl_distance)   Estimates probability of hitting TP before SL   Parameters:      src (float) : Source series (typically returns)      length (simple int) : Lookback for estimation      tp_distance (float) : Take profit distance (positive)      sl_distance (float) : Stop loss distance (positive)   Returns: Probability of TP being hit first trade_probability(src, length, tp_pct, sl_pct)   Calculates complete trade probability and EV analysis   Parameters:      src (float) : Source series (typically returns)      length (simple int) : Lookback period      tp_pct (float) : Take profit percentage      sl_pct (float) : Stop loss percentage   Returns: Tuple: cond_prob(condition_a, condition_b, length)   Calculates conditional probability P(B|A) from historical data   Parameters:      condition_a (bool) : Condition A (the given condition)      condition_b (bool) : Condition B (the outcome)      length (simple int) : Lookback period   Returns: P(B|A) = P(A and B) / P(A) bayes_update(prior, likelihood, false_positive)   Updates probability using Bayes' theorem   Parameters:      prior (float) : Prior probability P(H)      likelihood (float) : P(E|H) - probability of evidence given hypothesis      false_positive (float) : P(E|~H) - probability of evidence given hypothesis is false   Returns: Posterior probability P(H|E) streak_prob(win_rate, streak_length)   Calculates probability of N consecutive wins given win rate   Parameters:      win_rate (float) : Single-trade win probability      streak_length (simple int) : Number of consecutive wins   Returns: Probability of streak losing_streak_prob(win_rate, streak_length)   Calculates probability of experiencing N consecutive losses   Parameters:      win_rate (float) : Single-trade win probability      streak_length (simple int) : Number of consecutive losses   Returns: Probability of losing streak drawdown_prob(src, length, dd_threshold)   Estimates probability of drawdown exceeding threshold   Parameters:      src (float) : Source series (returns)      length (simple int) : Lookback period      dd_threshold (float) : Drawdown threshold (as positive decimal, e.g., 0.10 = 10%)   Returns: Historical probability of exceeding drawdown threshold prob_to_odds(prob)   Calculates odds from probability   Parameters:      prob (float) : Probability (0-1)   Returns: Odds (prob / (1 - prob)) odds_to_prob(odds)   Calculates probability from odds   Parameters:      odds (float) : Odds ratio   Returns: Probability (0-1) implied_prob(decimal_odds)   Calculates implied probability from decimal odds (betting)   Parameters:      decimal_odds (float) : Decimal odds (e.g., 2.5 means $2.50 return per $1 bet)   Returns: Implied probability logit(prob)   Calculates log-odds (logit) from probability   Parameters:      prob (float) : Probability (must be in (0, 1))   Returns: Log-odds inv_logit(log_odds)   Calculates probability from log-odds (inverse logit / sigmoid)   Parameters:      log_odds (float) : Log-odds value   Returns: Probability (0-1) linreg_slope(src, length)   Calculates linear regression slope   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 2)   Returns: Slope coefficient (change per bar) linreg_intercept(src, length)   Calculates linear regression intercept   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 2)   Returns: Intercept (predicted value at oldest bar in window) linreg_value(src, length)   Calculates predicted value at current bar using linear regression   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Predicted value at current bar (end of regression line) linreg_forecast(src, length, offset)   Forecasts value N bars ahead using linear regression   Parameters:      src (float) : Source series      length (simple int) : Lookback period for regression      offset (simple int) : Bars ahead to forecast (positive = future)   Returns: Forecasted value linreg_channel(src, length, mult)   Calculates linear regression channel with bands   Parameters:      src (float) : Source series      length (simple int) : Lookback period      mult (simple float) : Standard deviation multiplier for bands   Returns: Tuple: r_squared(src, length)   Calculates R-squared (coefficient of determination)   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: R² value where 1 = perfect linear fit adj_r_squared(src, length)   Calculates adjusted R-squared (accounts for sample size)   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Adjusted R² value std_error(src, length)   Calculates standard error of estimate (residual standard deviation)   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Standard error residual(src, length)   Calculates residual at current bar   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Residual (actual - predicted) residuals(src, length)   Returns array of all residuals in lookback window   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Array of residuals t_statistic(src, length)   Calculates t-statistic for slope coefficient   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: T-statistic (slope / standard error of slope) slope_pvalue(src, length)   Approximates p-value for slope t-test (two-tailed)   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Approximate p-value is_significant(src, length, alpha)   Tests if regression slope is statistically significant   Parameters:      src (float) : Source series      length (simple int) : Lookback period      alpha (simple float) : Significance level (default: 0.05)   Returns: true if slope is significant at alpha level trend_strength(src, length)   Calculates normalized trend strength based on R² and slope   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Trend strength where sign indicates direction trend_angle(src, length)   Calculates trend angle in degrees   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Angle in degrees (positive = uptrend, negative = downtrend) linreg_acceleration(src, length)   Calculates trend acceleration (second derivative)   Parameters:      src (float) : Source series      length (simple int) : Lookback period for each regression   Returns: Acceleration (change in slope) linreg_deviation(src, length)   Calculates deviation from regression line in standard error units   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Deviation in standard error units (like z-score) quadreg_coefficients(src, length)   Fits quadratic regression and returns coefficients   Parameters:      src (float) : Source series      length (simple int) : Lookback period (must be >= 4)   Returns: Tuple: for y = a*x² + b*x + c quadreg_value(src, length)   Calculates quadratic regression value at current bar   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: Predicted value from quadratic fit correlation(x, y, length)   Calculates Pearson correlation coefficient between two series   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback period (must be >= 3)   Returns: Correlation coefficient covariance(x, y, length)   Calculates sample covariance between two series   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback period (must be >= 2)   Returns: Covariance value beta(asset, benchmark, length)   Calculates beta coefficient (slope of regression of y on x)   Parameters:      asset (float) : Asset returns series      benchmark (float) : Benchmark returns series      length (simple int) : Lookback period   Returns: Beta coefficient @description Beta = Cov(asset, benchmark) / Var(benchmark) alpha(asset, benchmark, length, risk_free)   Calculates alpha (Jensen's alpha / intercept)   Parameters:      asset (float) : Asset returns series      benchmark (float) : Benchmark returns series      length (simple int) : Lookback period      risk_free (float) : Risk-free rate (default: 0)   Returns: Alpha value (excess return not explained by beta) spearman(x, y, length)   Calculates Spearman rank correlation coefficient   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback period (must be >= 3)   Returns: Spearman correlation @description More robust to outliers than Pearson correlation kendall_tau(x, y, length)   Calculates Kendall's tau rank correlation (simplified)   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback period (must be >= 3)   Returns: Kendall's tau correlation_change(x, y, length, change_period)   Calculates change in correlation over time   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback period for correlation      change_period (simple int) : Period over which to measure change   Returns: Change in correlation correlation_regime(x, y, length, ma_length)   Detects correlation regime based on level and stability   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback period for correlation      ma_length (simple int) : Moving average length for smoothing   Returns: Regime: -1 = negative, 0 = uncorrelated, 1 = positive correlation_stability(x, y, length, stability_length)   Calculates correlation stability (inverse of volatility)   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback for correlation      stability_length (simple int) : Lookback for stability calculation   Returns: Stability score where 1 = perfectly stable relative_strength(asset, benchmark, length)   Calculates relative strength of asset vs benchmark   Parameters:      asset (float) : Asset price series      benchmark (float) : Benchmark price series      length (simple int) : Smoothing period   Returns: Relative strength ratio (normalized) tracking_error(asset, benchmark, length)   Calculates tracking error (standard deviation of excess returns)   Parameters:      asset (float) : Asset returns      benchmark (float) : Benchmark returns      length (simple int) : Lookback period   Returns: Tracking error (annualize by multiplying by sqrt(252) for daily data) information_ratio(asset, benchmark, length)   Calculates information ratio (risk-adjusted excess return)   Parameters:      asset (float) : Asset returns      benchmark (float) : Benchmark returns      length (simple int) : Lookback period   Returns: Information ratio capture_ratio(asset, benchmark, length, up_capture)   Calculates up/down capture ratio   Parameters:      asset (float) : Asset returns      benchmark (float) : Benchmark returns      length (simple int) : Lookback period      up_capture (simple bool) : If true, calculate up capture; if false, down capture   Returns: Capture ratio autocorrelation(src, length, lag)   Calculates autocorrelation at specified lag   Parameters:      src (float) : Source series      length (simple int) : Lookback period      lag (simple int) : Lag for autocorrelation (default: 1)   Returns: Autocorrelation at specified lag partial_autocorr(src, length)   Calculates partial autocorrelation at lag 1   Parameters:      src (float) : Source series      length (simple int) : Lookback period   Returns: PACF at lag 1 (equals ACF at lag 1) autocorr_test(src, length, max_lag)   Tests for significant autocorrelation (Ljung-Box inspired)   Parameters:      src (float) : Source series      length (simple int) : Lookback period      max_lag (simple int) : Maximum lag to test   Returns: Sum of squared autocorrelations (higher = more autocorrelation) cross_correlation(x, y, length, lag)   Calculates cross-correlation at specified lag   Parameters:      x (float) : First series      y (float) : Second series (lagged)      length (simple int) : Lookback period      lag (simple int) : Lag to apply to y (positive = y leads x)   Returns: Cross-correlation at specified lag cross_correlation_peak(x, y, length, max_lag)   Finds lag with maximum cross-correlation   Parameters:      x (float) : First series      y (float) : Second series      length (simple int) : Lookback period      max_lag (simple int) : Maximum lag to search (both directions)   Returns: Tuple:
Biblioteca Pine Script®
por HenriqueCentieiro
1
Bulkowski Breakout vPRO (5m) - Runtime FixedHere is the English translation of your strategy guide, tailored for international traders while maintaining your encouraging tone.Strategy Guide: Bulkowski Breakout vPROFor Aspiring "Golden Traders"This strategy is designed for beginners to trade with the "flow of power." In short, it is a momentum-following strategy that enters a trade when a strong price move (Long Body Candle + High Volume) breaks through a key psychological level (200 EMA).1. Core Concept: "The High-Energy Breakout"Based on the principles of Thomas Bulkowski, a legendary master of chart patterns, this strategy prioritizes high-energy moves over simple price touches. A signal (LONG or SHORT) is only generated when these three conditions align:200 EMA Break (The Baseline): The 200-period Exponential Moving Average is the "life-line" of the market. Price breaking above this line indicates a powerful shift from a bearish to a bullish trend.Long Body Candle (Volatility): The candle body must be at least 2x larger than the recent average. This serves as evidence of institutional or "whale" buying/selling.Volume Surge (Reliability): Trading volume at the moment of breakout must be 1.5x higher than the recent average. This confirms the move is genuine and not a "fake-out."2. Session Filter (Optimized for Peak Volatility)To avoid "choppy" sideways markets, this strategy only operates during the first two hours of the major global market opens, when liquidity is at its highest.MarketTime (KST / UTC+9)Market CharacteristicsAsia Session09:00 ~ 11:00Opening of Korean, Japanese, and Chinese markets.Europe Session16:00 ~ 18:00Volatility spikes as the London market opens.US Session22:00 ~ 24:00Peak global liquidity as New York opens.Signals only appear when the chart background is shaded blue. All other times are "resting periods" to protect your capital.3. Execution GuideEntryLONG (Buy): Enter when a large green candle breaks above the yellow 200 EMA with high volume. (Green triangle label appears).SHORT (Sell): Enter when a large red candle breaks below the yellow 200 EMA with high volume. (Red triangle label appears).Take Profit (TP) & Stop Loss (SL)Lines are automatically drawn on your chart once you enter:Orange Line (Stop Loss): Automatically set at the low (or high) of the last 3 candles. If the price touches this, the trade closes to prevent further loss.Green Line (Take Profit): Automatically set at 1.5x your risk. This ensures a healthy 1:1.5 Risk-to-Reward ratio.4. Pro-Tips for BeginnersOptimized for 5m: This strategy works best on the 5-minute (5m) timeframe. 1m is often too noisy, and 15m can be too slow for scalping.Watch Bitcoin: Even if an altcoin gives a LONG signal, be cautious if Bitcoin is currently crashing. BTC dictates the overall market direction.Adjusting Sensitivity: If signals are too rare, go to "Settings" and lower the Long Body Multiplier from 2.0 to 1.5.This indicator is built to help you trade based on statistical advantages, not emotions. We strongly recommend practicing with Paper Trading first to get a feel for the signals.To everyone dreaming of becoming a Golden Trader—Success is a marathon, not a sprint!
Estrategia Pine Script®
por minovsajh
Intrabar Volume Flow IntelligenceIntrabar Volume Flow Intelligence: A Comprehensive Analysis: The Intrabar Volume Flow Intelligence indicator represents a sophisticated approach to understanding market dynamics through the lens of volume analysis at a granular, intrabar level. This Pine Script version 5 indicator transcends traditional volume analysis by dissecting price action within individual bars to reveal the true nature of buying and selling pressure that often remains hidden when examining only the external characteristics of completed candlesticks. At its core, this indicator operates on the principle that volume is the fuel that drives price movement, and by understanding where volume is being applied within each bar—whether at higher prices indicating buying pressure or at lower prices indicating selling pressure—traders can gain a significant edge in anticipating future price movements before they become obvious to the broader market. The foundational innovation of this indicator lies in its use of lower timeframe data to analyze what happens inside each bar on your chart timeframe. While most traders see only the open, high, low, and close of a five-minute candle, for example, this indicator requests data from a one-minute timeframe by default to see all the individual one-minute candles that comprise that five-minute bar. This intrabar analysis allows the indicator to calculate a weighted intensity score based on where the price closed within each sub-bar's range. If the close is near the high, that volume is attributed more heavily to buying pressure; if near the low, to selling pressure. This methodology is far more nuanced than simple tick volume analysis or even traditional volume delta calculations because it accounts for the actual price behavior and distribution of volume throughout the formation of each bar, providing a three-dimensional view of market participation. The intensity calculation itself demonstrates the coding sophistication embedded in this indicator. For each intrabar segment, the indicator calculates a base intensity using the formula of close minus low divided by the range between high and low. This gives a value between zero and one, where values approaching one indicate closes near the high and values approaching zero indicate closes near the low. However, the indicator doesn't stop there—it applies an open adjustment factor that considers the relationship between the close and open positions within the overall range, adding up to twenty percent additional weighting based on directional movement. This adjustment ensures that strongly directional intrabar movement receives appropriate emphasis in the final volume allocation. The adjusted intensity is then bounded between zero and one to prevent extreme outliers from distorting the analysis, demonstrating careful consideration of edge cases and data integrity. The volume flow calculation multiplies this intensity by the actual volume transacted in each intrabar segment, creating buy volume and sell volume figures that represent not just quantity but quality of market participation. These figures are accumulated across all intrabar segments within the parent bar, and simultaneously, a volume-weighted average price is calculated for the entire bar using the typical price of each segment multiplied by its volume. This intrabar VWAP becomes a critical reference point for understanding whether the overall bar is trading above or below its fair value as determined by actual transaction levels. The deviation from this intrabar VWAP is then used as a weighting mechanism—when the close is significantly above the intrabar VWAP, buying volume receives additional weight; when below, selling volume is emphasized. This creates a feedback loop where volume that moves price away from equilibrium is recognized as more significant than volume that keeps price near balance. The imbalance filter represents another layer of analytical sophistication that separates meaningful volume flows from normal market noise. The indicator calculates the absolute difference between buy and sell volume as a percentage of total volume, and this imbalance must exceed a user-defined threshold—defaulted to twenty-five percent but adjustable from five to eighty percent—before the volume flow is considered significant enough to register on the indicator. This filtering mechanism ensures that only bars with clear directional conviction contribute to the cumulative flow measurements, while bars with balanced buying and selling are essentially ignored. This is crucial because markets spend considerable time in equilibrium states where volume is simply facilitating position exchanges without directional intent. By filtering out these neutral periods, the indicator focuses trader attention exclusively on moments when one side of the market is demonstrating clear dominance. The decay factor implementation showcases advanced state management in Pine Script coding. Rather than allowing imbalanced volume to simply disappear after one bar, the indicator maintains decayed values using variable state that persists across bars. When a new significant imbalance occurs, it replaces the decayed value; when no significant imbalance is present, the previous value is multiplied by the decay factor, which defaults to zero point eight-five. This means that a large volume imbalance continues to influence the indicator for several bars afterward, gradually diminishing in impact unless reinforced by new imbalances. This decay mechanism creates persistence in the flow measurements, acknowledging that large institutional volume accumulation or distribution campaigns don't execute in single bars but rather unfold across multiple bars. The cumulative flow calculation then sums these decayed values over a lookback period, creating a running total that represents sustained directional pressure rather than momentary spikes. The dual moving average crossover system applied to these volume flows creates actionable trading signals from the underlying data. The indicator calculates both a fast exponential moving average and a slower simple moving average of the buy flow, sell flow, and net flow values. The use of EMA for the fast line provides responsiveness to recent changes while the SMA for the slow line provides a more stable baseline, and the divergence or convergence between these averages signals shifts in volume flow momentum. When the buy flow EMA crosses above its SMA while volume is elevated, this indicates that buying pressure is not only present but accelerating, which is the foundation for the strong buy signal generation. The same logic applies inversely for selling pressure, creating a symmetrical approach to detecting both upside and downside momentum shifts based on volume characteristics rather than price characteristics. The volume threshold filtering ensures that signals only generate during periods of statistically significant market participation. The indicator calculates a simple moving average of total volume over a user-defined period, defaulted to twenty bars, and then requires that current volume exceed this average by a multiplier, defaulted to one point two times. This ensures that signals occur during periods when the market is actively engaged rather than during quiet periods when a few large orders can create misleading volume patterns. The indicator even distinguishes between high volume—exceeding the threshold—and very high volume—exceeding one point five times the threshold—with the latter triggering background color changes to alert traders to exceptional participation levels. This tiered volume classification allows traders to calibrate their position sizing and conviction levels based on the strength of market participation supporting the signal. The flow momentum calculation adds a velocity dimension to the volume analysis. By calculating the rate of change of the net flow EMA over a user-defined momentum length—defaulted to five bars—the indicator measures not just the direction of volume flow but the acceleration or deceleration of that flow. A positive and increasing flow momentum indicates that buying pressure is not only dominant but intensifying, which typically precedes significant upward price movements. Conversely, negative and decreasing flow momentum suggests selling pressure is building upon itself, often preceding breakdowns. The indicator even calculates a second derivative—the momentum of momentum, termed flow acceleration—which can identify very early turning points when the rate of change itself begins to shift, providing the most forward-looking signal available from this methodology. The divergence detection system represents one of the most powerful features for identifying potential trend reversals and continuations. The indicator maintains separate tracking of price extremes and flow extremes over a lookback period defaulted to fourteen bars. A bearish divergence is identified when price makes a new high or equals the recent high, but the net flow EMA is significantly below its recent high—specifically less than eighty percent of that high—and is declining compared to its value at the divergence lookback distance. This pattern indicates that while price is pushing higher, the volume support for that movement is deteriorating, which frequently precedes reversals. Bullish divergences work inversely, identifying situations where price makes new lows without corresponding weakness in volume flow, suggesting that selling pressure is exhausted and a reversal higher is probable. These divergence signals are plotted as distinct diamond shapes on the indicator, making them visually prominent for trader attention. The accumulation and distribution zone detection provides a longer-term context for understanding institutional positioning. The indicator uses the bars-since function to track consecutive periods where the net flow EMA has remained positive or negative. When buying pressure has persisted for at least five consecutive bars, average intensity exceeds zero point six indicating strong closes within bar ranges, and volume is elevated above the threshold, the indicator identifies an accumulation zone. These zones suggest that smart money is systematically building long positions across multiple bars despite potentially choppy or sideways price action. Distribution zones are identified through the inverse criteria, revealing periods when institutions are systematically exiting or building short positions. These zones are visualized through colored fills on the indicator pane, creating a backdrop that helps traders understand the broader volume flow context beyond individual bar signals. The signal strength scoring system provides a quantitative measure of conviction for each buy or sell signal. Rather than treating all signals as equal, the indicator assigns point values to different signal components: twenty-five points for the buy flow EMA-SMA crossover, twenty-five points for the net flow EMA-SMA crossover, twenty points for high volume presence, fifteen points for positive flow momentum, and fifteen points for bullish divergence presence. These points are summed to create a buy score that can range from zero to one hundred percent, with higher scores indicating that multiple independent confirmation factors are aligned. The same methodology creates a sell score, and these scores are displayed in the information table, allowing traders to quickly assess whether a signal represents a tentative suggestion or a high-conviction setup. This scoring approach transforms the indicator from a binary signal generator into a nuanced probability assessment tool. The visual presentation of the indicator demonstrates exceptional attention to user experience and information density. The primary display shows the net flow EMA as a thick colored line that transitions between green when above zero and above its SMA, indicating strong buying, to a lighter green when above zero but below the SMA, indicating weakening buying, to red when below zero and below the SMA, indicating strong selling, to a lighter red when below zero but above the SMA, indicating weakening selling. This color gradient provides immediate visual feedback about both direction and momentum of volume flows. The net flow SMA is overlaid in orange as a reference line, and a zero line is drawn to clearly delineate positive from negative territory. Behind these lines, a histogram representation of the raw net flow—scaled down by thirty percent for visibility—shows bar-by-bar flow with color intensity reflecting whether flow is strengthening or weakening compared to the previous bar. This layered visualization allows traders to simultaneously see the raw data, the smoothed trend, and the trend of the trend, accommodating both short-term and longer-term trading perspectives. The cumulative delta line adds a macro perspective by maintaining a running sum of all volume deltas divided by one million for scale, plotted in purple as a separate series. This cumulative measure acts similar to an on-balance volume calculation but with the sophisticated volume attribution methodology of this indicator, creating a long-term sentiment gauge that can reveal whether an asset is under sustained accumulation or distribution across days, weeks, or months. Divergences between this cumulative delta and price can identify major trend exhaustion or reversal points that might not be visible in the shorter-term flow measurements. The signal plotting uses shape-based markers rather than background colors or arrows to maximize clarity while preserving chart space. Strong buy signals—meeting multiple criteria including EMA-SMA crossover, high volume, and positive momentum—appear as full-size green triangle-up shapes at the bottom of the indicator pane. Strong sell signals appear as full-size red triangle-down shapes at the top. Regular buy and sell signals that meet fewer criteria appear as smaller, semi-transparent circles, indicating they warrant attention but lack the full confirmation of strong signals. Divergence-based signals appear as distinct diamond shapes in cyan for bullish divergences and orange for bearish divergences, ensuring these critical reversal indicators are immediately recognizable and don't get confused with momentum-based signals. This multi-tiered signal hierarchy helps traders prioritize their analysis and avoid signal overload. The information table in the top-right corner of the indicator pane provides real-time quantitative feedback on all major calculation components. It displays the current bar's buy volume and sell volume in millions with appropriate color coding, the imbalance percentage with color indicating whether it exceeds the threshold, the average intensity score showing whether closes are generally near highs or lows, the flow momentum value, and the current buy and sell scores. This table transforms the indicator from a purely graphical tool into a quantitative dashboard, allowing discretionary traders to incorporate specific numerical thresholds into their decision frameworks. For example, a trader might require that buy score exceed seventy percent and intensity exceed zero point six-five before taking a long position, creating objective entry criteria from subjective chart reading. The background shading that occurs during very high volume periods provides an ambient alert system that doesn't require focused attention on the indicator pane. When volume spikes to one point five times the threshold and net flow EMA is positive, a very light green background appears across the entire indicator pane; when volume spikes with negative net flow, a light red background appears. These backgrounds create a subliminal awareness of exceptional market participation moments, ensuring traders notice when the market is making important decisions even if they're focused on price action or other indicators at that moment. The alert system built into the indicator allows traders to receive notifications for strong buy signals, strong sell signals, bullish divergences, bearish divergences, and very high volume events. These alerts can be configured in TradingView to send push notifications to mobile devices, emails, or webhook calls to automated trading systems. This functionality transforms the indicator from a passive analysis tool into an active monitoring system that can watch markets continuously and notify the trader only when significant volume flow developments occur. For traders monitoring multiple instruments, this alert capability is invaluable for efficient time allocation, allowing them to analyze other opportunities while being instantly notified when this indicator identifies high-probability setups on their watch list. The coding implementation demonstrates advanced Pine Script techniques including the use of request.security_lower_tf to access intrabar data, array manipulation to process variable-length intrabar arrays, proper variable scoping with var keyword for persistent state management across bars, and efficient conditional logic that prevents unnecessary calculations. The code structure with clearly delineated sections for inputs, calculations, signal generation, plotting, and alerts makes it maintainable and educational for those studying Pine Script development. The use of input groups with custom headers creates an organized settings panel that doesn't overwhelm users with dozens of ungrouped parameters, while still providing substantial customization capability for advanced users who want to optimize the indicator for specific instruments or timeframes. For practical trading application, this indicator excels in several specific use cases. Scalpers and day traders can use the intrabar analysis to identify accumulation or distribution happening within the bars of their entry timeframe, providing early entry signals before momentum indicators or price patterns complete. Swing traders can use the cumulative delta and accumulation-distribution zones to understand whether short-term pullbacks in an uptrend are being bought or sold, helping distinguish between healthy retracements and trend reversals. Position traders can use the divergence detection to identify major turning points where price extremes are not supported by volume, providing low-risk entry points for counter-trend positions or warnings to exit with-trend positions before significant reversals. The indicator is particularly valuable in ranging markets where price-based indicators produce numerous false breakout signals. By requiring that breakouts be accompanied by volume flow imbalances, the indicator filters out failed breakouts driven by low participation. When price breaks a range boundary accompanied by a strong buy or sell signal with high buy or sell score and very high volume, the probability of successful breakout follow-through increases dramatically. Conversely, when price breaks a range but the indicator shows low imbalance, opposing flow direction, or low volume, traders can fade the breakout or at minimum avoid chasing it. During trending markets, the indicator helps traders identify the healthiest entry points by revealing where pullbacks are being accumulated by smart money. A trending market will show the cumulative delta continuing in the trend direction even as price pulls back, and accumulation zones will form during these pullbacks. When price resumes the trend, the indicator will generate strong buy or sell signals with high scores, providing objective entry points with clear invalidation levels. The flow momentum component helps traders stay with trends longer by distinguishing between healthy momentum pauses—where momentum goes to zero but doesn't reverse—and actual momentum reversals where opposing pressure is building. The VWAP deviation weighting adds particular value for traders of liquid instruments like major forex pairs, stock indices, and high-volume stocks where VWAP is widely watched by institutional participants. When price deviates significantly from the intrabar VWAP and volume flows in the direction of that deviation with elevated weighting, it indicates that the move away from fair value is being driven by conviction rather than mechanical order flow. This suggests the deviation will likely extend further, creating continuation trading opportunities. Conversely, when price deviates from intrabar VWAP but volume flow shows reduced intensity or opposing direction despite the weighting, it suggests the deviation will revert to VWAP, creating mean reversion opportunities. The ATR normalization option makes the indicator values comparable across different volatility regimes and different instruments. Without normalization, a one-million share buy-sell imbalance might be significant for a low-volatility stock but trivial for a high-volatility cryptocurrency. By normalizing the delta by ATR, the indicator accounts for the typical price movement capacity of the instrument, making signal thresholds and comparison values meaningful across different trading contexts. This is particularly valuable for traders running the indicator on multiple instruments who want consistent signal quality regardless of the underlying instrument characteristics. The configurable decay factor allows traders to adjust how persistent they want volume flows to remain influential. For very short-term scalping, a lower decay factor like zero point five will cause volume imbalances to dissipate quickly, keeping the indicator focused only on very recent flows. For longer-term position trading, a higher decay factor like zero point nine-five will allow significant volume events to influence the indicator for many bars, revealing longer-term accumulation and distribution patterns. This flexibility makes the single indicator adaptable to trading styles ranging from one-minute scalping to daily chart position trading simply by adjusting the decay parameter and the lookback bars. The minimum imbalance percentage setting provides crucial noise filtering that can be optimized per instrument. Highly liquid instruments with tight spreads might show numerous small imbalances that are meaningless, requiring a higher threshold like thirty-five or forty percent to filter noise effectively. Thinly traded instruments might rarely show extreme imbalances, requiring a lower threshold like fifteen or twenty percent to generate adequate signals. By making this threshold user-configurable with a wide range, the indicator accommodates the full spectrum of market microstructure characteristics across different instruments and timeframes. In conclusion, the Intrabar Volume Flow Intelligence indicator represents a comprehensive volume analysis system that combines intrabar data access, sophisticated volume attribution algorithms, multi-timeframe smoothing, statistical filtering, divergence detection, zone identification, and intelligent signal scoring into a cohesive analytical framework. It provides traders with visibility into market dynamics that are invisible to price-only analysis and even to conventional volume analysis, revealing the true intentions of market participants through their actual transaction behavior within each bar. The indicator's strength lies not in any single feature but in the integration of multiple analytical layers that confirm and validate each other, creating high-probability signal generation that can form the foundation of complete trading systems or provide powerful confirmation for discretionary analysis. For traders willing to invest time in understanding its components and optimizing its parameters for their specific instruments and timeframes, this indicator offers a significant informational advantage in increasingly competitive markets where edge is derived from seeing what others miss and acting on that information before it becomes consensus.
Indicador Pine Script®
por jaydesaigu
MTF Dynamic MA TrackerThis indicator allows you to track the behavior of price relative to a key Moving Average across up to 9 different timeframes simultaneously. The idea behind this tool is to see what your favourite MA is doing at various TFs while solving the problem of "chart clutter." Plotting 9 different Moving Averages on a single chart usually results in a messy interface that is hard to read. This script solves that using Dynamic Dimming. Default Settings: By default, the script is configured to track the EMA 200 (Exponential Moving Average). However, this is for illustration purposes only. You can fully customize the indicator to track your preferred Moving Average Type (EMA, SMA, HMA, WMA, or RMA) and your preferred Length (e.g., 50, 100, 200) in the settings menu. Key Features: Multi-Timeframe Tracking: Monitor your chosen Moving Average across 9 user-defined timeframes (e.g., 1m, 5m, 15m, 1H, 4H, Daily, etc.) directly on your current chart. Dynamic Visibility (Dimming): By default, the MA lines remain transparent (dimmed) to keep your chart clean. The lines automatically brighten (light up) only when the price comes within a specific proximity of the MA. This highlights immediate Support or Resistance levels without visual noise. You can customize the "Proximity Method" using either a Percentage of price or an ATR multiplier. Tag Detection & Alerts: The script detects "Tags"—moments where price interacts with a Moving Average (e.g., wicks into it and closes back above/below). Bull Tag (Support): Price dips into the MA but closes above it. Bear Tag (Resistance): Price spikes into the MA but closes below it. You can set alerts to trigger whenever these interactions occur on any monitored timeframe. Dashboard (Nexus): A status table displays "Clusters" (when price is near multiple MAs simultaneously) and lists any active Bull/Bear tags occurring on the current bar. Customization: MA Type: Choose between EMA, SMA, HMA, WMA, or RMA. MA Length: Input any length (Default: 200). Timeframes: Individually enable/disable and select up to 9 specific timeframes. Dimming: Adjust the transparency for "dimmed" vs "bright" states.
Indicador Pine Script®
por ChiragPatnaik
Delta Volume EMA Strategy ================================================================================ DELTA VOLUME EMA STRATEGY - STRATEGY GUIDE 📊 ================================================================================ 💡 COLLABORATION & SUPPORT --------------------------- If you want to collaborate, have an idea for a strategy, or need help writing or customizing code, send an email to burdytrader@gmail.com or send me a message. Suggestions, ideas, and comments are always welcome! 🤝 ================================================================================ ⚠️ IMPORTANT: INSTRUMENT SELECTION 📈 ------------------------------------- This strategy performs BEST with instruments that have a centralized data flow, such as Futures contracts. Centralized markets provide more accurate and reliable volume data, which is essential for Volume Delta analysis to work effectively. Why Futures? 🎯 - Centralized exchange = Accurate volume data - All trades flow through a single exchange - Volume reflects true buying/selling pressure - Better correlation between volume and price movements While the strategy can work with other instruments (stocks, forex, etc.), volume data quality may vary, which can affect the reliability of Volume Delta signals. For optimal performance, use Futures contracts or other instruments with centralized, high-quality volume data. ================================================================================ WHAT DOES THIS STRATEGY DO? 🎯 --------------------------- This strategy uses Volume Delta analysis combined with Exponential Moving Averages (EMA) to identify high-probability trading opportunities. The Volume Delta measures the difference between buying and selling pressure, helping to identify when strong institutional or smart money movements occur. The strategy automatically enters trades when volume delta reaches extreme levels, indicating potential trend continuation or reversal points. HOW IT WORKS? ⚙️ --------------- 1. VOLUME DELTA CALCULATION 📈 The strategy calculates the Volume Delta using the following formula: - Volume Ratio (v) = Current Volume / Previous Volume - EMA of Close (mac) = EMA(Close, MA Length) × Volume Ratio - EMA of Open (mao) = EMA(Open, MA Length) × Volume Ratio - Volume Delta (vd) = mac - mao The Volume Delta shows: - Positive values (green) = Buying pressure (buyers are more active) - Negative values (red) = Selling pressure (sellers are more active) 2. VOLUME DELTA MOVING AVERAGE 📊 The strategy calculates an EMA of the Volume Delta (vdma) to smooth out fluctuations and identify the overall trend of buying/selling pressure: - vdma = EMA(Volume Delta, EMA Length) - When vdma is above zero = Overall buying pressure - When vdma is below zero = Overall selling pressure 3. PERCENTILE-BASED ENTRY CONDITIONS 🎲 Instead of using fixed thresholds, the strategy uses percentile analysis to identify extreme volume delta movements: For LONG entries: - Analyzes seller volumes (negative volume delta) over the lookback period - Calculates the percentile threshold (default: 80th percentile) - Enters LONG when volume delta becomes positive AND exceeds the threshold - This indicates a strong shift from selling to buying pressure For SHORT entries: - Analyzes buyer volumes (positive volume delta) over the lookback period - Calculates the percentile threshold (default: 80th percentile) - Enters SHORT when volume delta becomes negative AND exceeds the threshold - This indicates a strong shift from buying to selling pressure 4. POSITION SIZING 💰 The strategy offers two position sizing methods: a) RISK VALUE (Fixed Risk in Dollars): - Calculates position size based on a fixed dollar risk amount - Formula: Position Size = Risk Amount / (Entry Price × Stop Loss %) - Ensures consistent risk per trade regardless of price level b) LOTS SIZE: - Uses a fixed lot size for all trades - Simple and straightforward approach - Useful when you want consistent position sizes 5. TAKE PROFIT & STOP LOSS SETTINGS 🎯 The strategy offers flexible TP/SL configuration in three modes: a) PERCENTAGE (%): - TP/SL calculated as a percentage of entry price - Example: 2% TP means entry price × 1.02 (for LONG) or × 0.98 (for SHORT) - Adapts automatically to different price levels b) CURRENCY: - TP/SL set as a fixed currency amount - Example: $100 TP means entry price + $100 (for LONG) or - $100 (for SHORT) - Useful for instruments with consistent price movements c) PIPS: - TP/SL set as a fixed number of pips - Automatically converts pips to price using the instrument's minimum tick - Ideal for forex and other pip-based instruments 6. AUTOMATIC TRADE EXECUTION ⚡ When entry conditions are met: - Opens a position (LONG or SHORT) at market price - Automatically sets Take Profit and Stop Loss based on selected mode - Sends an alert with all trade information - Only one position at a time (waits for current position to close) AVAILABLE PARAMETERS ⚙️ ---------------------- 1. MA LENGTH (Default: 10) - Length of the Exponential Moving Average used for close and open prices - Lower values = More sensitive to recent price action - Higher values = More smoothed, less sensitive 2. EMA LENGTH (Default: 20) - Length of the EMA applied to Volume Delta - Controls the smoothing of the volume delta signal - Lower values = Faster signals, more trades - Higher values = Slower signals, fewer but potentially more reliable trades 3. POSITION SIZE MODE - "Risk Value": Calculate position size based on fixed dollar risk - "Lots Size": Use fixed lot size for all trades 4. FIXED RISK IN $ (Default: 50) - Only used when Position Size Mode = "Risk Value" - The dollar amount you're willing to risk per trade - Strategy calculates position size automatically 5. LOT SIZE (Default: 0.01) - Only used when Position Size Mode = "Lots Size" - Fixed lot size for all trades 6. TAKE PROFIT MODE - "%": Percentage of entry price - "Currency": Fixed currency amount - "Pips": Fixed number of pips 7. STOP LOSS MODE - "%": Percentage of entry price - "Currency": Fixed currency amount - "Pips": Fixed number of pips 8. TAKE PROFIT / STOP LOSS VALUES - Different input fields appear based on selected mode - Configure TP and SL independently 9. VOLUME LOOKBACK PERIOD (Default: 20) - Number of bars used to calculate percentile thresholds - Lower values = More sensitive, adapts faster to recent conditions - Higher values = More stable, uses longer-term statistics 10. PERCENTILE THRESHOLD (Default: 80%) - The percentile level used to identify extreme volume delta movements - 80% means: only enter when volume delta exceeds 80% of recent values - Higher values = Fewer but potentially stronger signals - Lower values = More frequent signals VISUALIZATION 📊 --------------- The strategy displays on the chart: 1. VOLUME DELTA COLUMNS - Green columns = Positive volume delta (buying pressure) - Red columns = Negative volume delta (selling pressure) - Height represents the magnitude of buying/selling pressure 2. VOLUME DELTA MA AREA - Two overlapping area plots showing the smoothed volume delta - Black area (base layer) for overall visualization - Green area (when positive) = Overall buying pressure trend - Red area (when negative) = Overall selling pressure trend - Helps identify the dominant market sentiment 3. ZERO LINE - Horizontal line at zero - Helps visualize when buying/selling pressure crosses the neutral point ALERTS 🔔 -------- When enabled, the strategy sends alerts when a trade is opened. The alert message includes: - Direction: "Buy" for LONG positions or "Sell" for SHORT positions - Entry Price: The price at which the position was opened - TP (Take Profit): The target profit price - SL (Stop Loss): The stop loss price Example alert message: "Buy | Entry: 1.2050 | TP: 1.2250 | SL: 1.1950" Alerts can be configured in TradingView to send notifications via email, SMS, webhooks, or other platforms. RECOMMENDED SETTINGS 🎯 ----------------------- To get started, you can use these settings: STRATEGY PARAMETERS: - MA Length: 10 (default) - EMA Length: 20 (default) - Volume Lookback Period: 20 (default) - Percentile Threshold: 80% (default) POSITION SIZING: - Position Size Mode: "Risk Value" (for risk management) - Fixed Risk in $: Adjust based on your account size (e.g., 1-2% of account) - OR use "Lots Size" with 0.01 lots for small accounts TAKE PROFIT & STOP LOSS: - TP Mode: "%" (recommended for most instruments) - SL Mode: "%" (recommended for most instruments) - Take Profit (%): 2.0% (adjust based on your risk/reward preference) - Stop Loss (%): 1.0% (adjust based on your risk tolerance) For Forex: - Consider using "Pips" mode for TP/SL - Typical values: 20-50 pips TP, 10-30 pips SL For Stocks/Indices: - Use "%" mode for TP/SL - Typical values: 2-5% TP, 1-2% SL PRACTICAL EXAMPLE 📝 ------------------- Scenario: LONG Entry on EUR/USD 1. Market conditions: - Price: 1.1000 - Volume Delta becomes strongly positive - Volume Delta exceeds 80th percentile of recent seller volumes 2. Strategy calculates: - Entry Price: 1.1000 (current close) - Position Size Mode: "Risk Value" - Fixed Risk: $50 - Stop Loss Mode: "%" - Stop Loss: 1.0% - Position Size = $50 / (1.1000 × 0.01) = 4.55 lots 3. Strategy opens position: - Direction: LONG (Buy) - Entry: 1.1000 - Take Profit: 1.1220 (2% above entry) - Stop Loss: 1.0890 (1% below entry) - Alert sent: "Buy | Entry: 1.1000 | TP: 1.1220 | SL: 1.0890" 4. Outcome scenarios: - If price rises to 1.1220 → Take Profit hit (profit) - If price falls to 1.0890 → Stop Loss hit (loss limited to $50) IMPORTANT NOTE ⚠️ ----------------- This strategy is a technical analysis tool based on volume delta analysis. Like all trading strategies, it does NOT guarantee profits. Trading involves significant risks and you can lose money, including your entire investment. Past performance does not guarantee future results. Always: - Use appropriate risk management - Never risk more than you can afford to lose - Test the strategy on historical data (backtesting) before using real money - Start with small position sizes or paper trading - Understand that no strategy works 100% of the time - Consider market conditions, news events, and other factors - Keep a trading journal to learn and improve The author and contributors are NOT responsible for any losses incurred from using this strategy. Trading decisions are your own responsibility. Profits are NOT guaranteed, and losses are possible. LICENSE 📄 --------- This code is open source and available for modification. You are free to use, modify, and distribute this strategy. If you republish or share a modified version, please kindly mention the original author. ================================================================================
Estrategia Pine Script®
por Burdiga84
Dynamic Pivot Point [MarkitTick]Title: Dynamic Pivot Point MarkitTick Concept Unlike traditional Pivot Points, which plot static horizontal levels based on the previous period's High, Low, and Close, this script introduces a dynamic element by applying an Exponential Moving Average (EMA) to the calculated pivot levels. This approach allows the Support and Resistance zones to adapt more fluidly to recent price action, reducing the jagged steps often seen in standard multi-timeframe pivot indicators. How It Works The script operates in two distinct phases of calculation: 1. Data Extraction and Core Math: The indicator first requests the High, Low, and Close data from a user-defined timeframe (e.g., Daily, Weekly). Using this data, it calculates the standard Pivot Point (P) alongside three levels of Support (S1, S2, S3) and three levels of Resistance (R1, R2, R3) using standard geometric formulas: Pivot = (High + Low + Close) / 3 R1 = 2 * Pivot - Low S1 = 2 * Pivot - High (Subsequent levels follow standard Floor Pivot logic). 2. Dynamic Smoothing: Instead of plotting these raw values directly, the script processes each calculated level (P, S1-S3, R1-R3) through an Exponential Moving Average (EMA). The length of this EMA is controlled by the Pivot Length input. This smoothing process filters out minor volatility and creates curved, dynamic trajectories for the pivot levels rather than static straight lines. How to Use Traders can use this tool to identify dynamic areas of interest where price may react. The White Line represents the Central Pivot. Price action relative to this line helps determine the immediate bias (above for bullish, below for bearish). Green Lines (Support 1, 2, 3) indicate potential demand zones where price may bounce during a downtrend. Red Lines (Resistance 1, 2, 3) indicate potential supply zones where price may reject during an uptrend. Because the levels are smoothed, they can also act as dynamic trend followers, similar to moving averages, but derived from pivot geometry. Settings Show Pivot Points: Toggles the visibility of the plot lines on the chart. Pivot Length: Defines the lookback period for the EMA smoothing applied to the pivot levels. A higher number results in smoother, slower-reacting lines. Timeframe: Determines the timeframe used for the underlying High/Low/Close data (e.g., selecting "D" calculates pivots based on Daily data while viewing a lower timeframe chart). Disclaimer This tool is for educational and technical analysis purposes only. Breakouts can fail (fake-outs), and past geometric patterns do not guarantee future price action. Always manage risk and use this tool in conjunction with other forms of analysis.
Indicador Pine Script®
por MarkitTick
Filtered TEMA CrossoverFiltered Dual TEMA Crossover This indicator is a trend-following tool based on the classic Dual Triple Exponential Moving Average (TEMA) Crossover strategy, enhanced with two robust filters: the Chop Index and the Average Directional Index (ADX). The TEMA is known for its low lag and high responsiveness, making the crossover an effective signal for trend reversals. However, trading TEMA crossovers during sideways, choppy markets often leads to false signals. This is where the filters come in. Key Features ▪️Dual TEMA Crossover: Plots two customizable TEMA lines (Fast and Slow) for clear visualization of the primary trend direction. ▪️Intelligent Signal Filtering: Buy and Sell signals are generated only when the market confirms it is in a trending state, thanks to two integrated filters: ➖Chop Index Filter: Blocks signals when the market is detected as sideways or consolidating (Chop Index reading above a user-defined threshold). ➖ADX Filter: Ensures signals are only taken when the trend strength is sufficient (ADX reading above a user-defined minimum threshold). ▪️Customizable Signals: Full control over the signal shapes (Arrows, Triangles, etc.), colors, text, and size. How to Use It Use the Filtered Dual TEMA Crossover to enter positions on trend continuation or reversal while dramatically reducing exposure to low-quality, whipsawing signals common in non-trending environments. Before the filters: After the filters: Minimize Noise. Maximize Clarity. Trade the Trend.
Indicador Pine Script®
por ZAUTEC
Volume Threshold Levels - Crypto LidyaVolume Threshold Levels – Crypto Lidya Understanding volume behavior is one of the most effective ways to detect trend changes, manipulation candles, aggressive entries, and institutional activity. Volume Threshold Levels (VTL) not only displays raw volume but also calculates dynamic volume thresholds (2x – 3x – 4x) based on the moving average, allowing you to identify statistically meaningful volume anomalies with precision. 📌 1. Volume Columns The indicator plots each bar’s volume using traditional column-style visualization. Green: Bullish candle Red: Bearish candle Gray: Neutral candle This helps traders clearly understand the relationship between price and volume. 📌 2. Average Volume Area VTL offers two types of moving averages for volume: SMA (Simple Moving Average) EMA (Exponential Moving Average) The average volume is drawn as a soft yellow area across the chart. This area acts as the baseline for normal volume levels. 📌 3. Dynamic Threshold Lines (2x / 3x / 4x) The script calculates and displays multipliers of the average volume: 2x Average 3x Average 4x Average These levels appear as bright yellow lines. They are extremely useful for identifying breakouts, traps, and aggressive institutional entries. 📌 4. Volume Spike Detection (Alerts) VTL identifies upward crossovers where volume breaks above key levels: 1x Volume Signal 2x Volume Signal 3x Volume Signal 4x Volume Signal These can be used directly as TradingView alerts. This allows you to automate detection of high-impact volume spikes. 📌 5. Use Cases The indicator performs exceptionally well in: Breakout confirmation Liquidity sweep analysis Detecting manipulation candles Combining with OB, FVG, or other SMC structures Scalping and low-timeframe aggressive volume interpretation Algorithmic filters for volume-based strategies 📌 6. Summary VTL delivers: ✔ Dynamic average volume baseline ✔ Clear 2x–3x–4x volume thresholds ✔ Accurate detection of upside volume explosions ✔ A strong tool for traders who rely on volume confirmation Completely open-source and ready to be extended.
Indicador Pine Script®
por CryptoLidyaPro
1
Multi MAThis TradingView indicator displays four customizable moving averages on your price chart: two Exponential Moving Averages (EMAs) and two Simple Moving Averages (SMAs). The default settings show a 10-period EMA (aqua), 21-period EMA (orange), 50-period SMA (green), and 200-period SMA (red), which are commonly used timeframes for trend analysis. Each moving average can be individually toggled on or off, and their lengths and colors are fully adjustable through the indicator settings. The EMAs react more quickly to price changes while the SMAs provide smoother, more gradual trend indicators, making this useful for identifying support/resistance levels and trend direction. Traders often watch for crossovers between these moving averages as potential entry or exit signals, with the 50/200 SMA cross being particularly significant as the "golden cross" or "death cross."
Indicador Pine Script®
por OneMorningStar1
Multi-Symbol EMA Crossover Scanner with Multi-Timeframe AnalysisDescription What This Indicator Does: This indicator is a comprehensive market scanner that monitors up to 10 symbols simultaneously across 4 different timeframes (15-minute, 1-hour, 4-hour, and daily) to detect exponential moving average (EMA) crossovers in real-time. Instead of manually checking multiple charts and timeframes for EMA crossover signals, this scanner automatically does the work for you and presents all detected signals in a clean, organized table that updates continuously throughout the trading session. Key Features: Multi-Symbol Monitoring: Scan up to 10 different symbols at once (stocks, forex, crypto, or any TradingView symbol) Multi-Timeframe Analysis: Simultaneously tracks 4 timeframes (15m, 1H, 4H, 1D) with toggle options to enable/disable each Comprehensive EMA Pairs: Detects crossovers between all major EMA combinations: 20×50, 20×100, 20×200, 50×100, 50×200, and 100×200 Real-Time Signal Feed: Displays the most recent signals in a sorted table (newest first) with timestamp, direction, price, and EMA pair information Session Filter: Built-in time filter (default 10:00-18:00) to focus on specific trading hours and avoid pre-market/after-hours noise Pagination System: Navigate through signals using a page selector when you have more signals than fit in one view Signal Statistics: Footer displays total signals, bullish/bearish breakdown, and page navigation hints Customizable Display: Choose table position (4 corners), signals per page (5-20), and maximum signal history (10-100) How It Works: The scanner uses the request.security() function to fetch EMA data from multiple symbols and timeframes simultaneously. For each symbol-timeframe combination, it calculates four exponential moving averages (20, 50, 100, and 200 periods) and monitors for crossovers: Bullish Crossovers (▲ Green): Faster EMA crosses above slower EMA Indicates potential upward momentum Common entry signals for long positions Bearish Crossovers (▼ Red): Faster EMA crosses below slower EMA Indicates potential downward momentum Common entry signals for short positions or exits The scanner prioritizes crossovers involving faster EMAs (20×50) over slower ones (100×200), as faster crossovers typically generate more frequent signals. Each detected crossover is stored with its timestamp, allowing the scanner to sort signals chronologically and remove duplicates within the same timeframe. Signal Table Columns: Sym: Symbol name (abbreviated, e.g., "ASELS" instead of "BIST:ASELS") TF: Timeframe where the crossover occurred (15m, 1h, 4h, 1D) ⏰: Exact time of the crossover (HH:MM format in Istanbul timezone) ↕: Direction indicator (▲ bullish green / ▼ bearish red) ₺: Price level where the crossover occurred (average of the two EMAs) MA: Which EMA pair crossed (e.g., "20×50", "50×200") How to Use: For Day Traders: Enable 15m and 1h timeframes Monitor symbols from your watchlist Use crossovers as entry timing signals in the direction of the larger trend Adjust the time filter to match your trading session (e.g., market open to 2 hours before close) For Swing Traders: Enable 4h and 1D timeframes Focus on 50×200 and 100×200 crossovers (golden/death crosses) Look for multiple timeframe confluence (same symbol showing bullish crossovers on both 4h and 1D) Use as a pre-market scanner to identify potential setups for the day For Multi-Market Traders: Mix symbols from different markets (stocks, forex, crypto) Use the scanner to identify which markets are showing the most momentum Track relative strength by comparing crossover frequency across symbols Identify rotation opportunities when one asset shows bullish signals while another shows bearish Setup Recommendations: Default BIST (Turkish Stock Market) Setup: The code comes pre-configured with 10 popular BIST stocks: ASELS, EKGYO, THYAO, AKBNK, PGSUS, ASTOR, OTKAR, ALARK, ISCTR, BIMAS For US Stocks: Replace with symbols like: NASDAQ:AAPL, NASDAQ:TSLA, NASDAQ:NVDA, NYSE:JPM, etc. For Forex: Use pairs like: FX:EURUSD, FX:GBPUSD, FX:USDJPY, OANDA:XAUUSD, etc. For Crypto: Use exchanges like: BINANCE:BTCUSDT, COINBASE:ETHUSD, BINANCE:SOLUSDT, etc. Settings Guide: Symbol List (10 inputs): Enter any valid TradingView symbol in "EXCHANGE:TICKER" format Use symbols you actively trade or monitor Mix different asset classes if desired Timeframe Toggles: 15 Minutes: High-frequency signals, best for day trading 1 Hour: Balanced frequency, good for intraday swing trades 4 Hours: Lower frequency, quality swing trade signals 1 Day: Low frequency, major trend changes only Time Filter: Start Hour (10): Beginning of your trading session End Hour (18): End of your trading session Prevents signals during low-liquidity periods Adjust to match your market's active hours Display Settings: Table Position: Choose corner placement (doesn't interfere with other indicators) Max Signals (40): Total historical signals to keep in memory Signals Per Page (10): How many rows to show at once Page Number: Navigate through signal history (auto-adjusts to available pages) What Makes This Original: Multi-symbol scanners exist on TradingView, but this indicator's originality comes from: Comprehensive EMA Pair Coverage: Most scanners focus on 1-2 EMA pairs, this monitors 6 different combinations simultaneously Unified Multi-Timeframe View: Presents signals from 4 timeframes in a single, chronologically sorted feed rather than separate panels Session-Aware Filtering: Built-in time filter prevents signal overload from 24-hour markets Smart Pagination: Handles large signal volumes gracefully with page navigation instead of scrolling Signal Deduplication: Prevents the same crossover from appearing multiple times if it persists across several bars Price-at-Cross Recording: Captures the exact price where the crossover occurred, not just that it happened Real-Time Statistics: Live tracking of bullish vs bearish signal distribution Trading Strategy Examples: Trend Confirmation Strategy: Find a symbol showing bullish crossover on 1D (major trend change) Wait for pullback Enter when 1h shows bullish crossover (confirmation) Exit when 1h shows bearish crossover Multi-Timeframe Confluence: Look for symbols appearing multiple times with same direction Example: ASELS shows ▲ on both 4h and 1D = strong bullish signal Avoid symbols showing conflicting signals (▲ on 1h but ▼ on 4h) Rotation Scanner: Monitor 10+ symbols from the same sector Identify which are turning bullish (▲) first Enter leaders, avoid laggards Rotate out when crossovers turn bearish (▼) Important Considerations: Not a Complete System: EMA crossovers should be confirmed with price action, volume, and support/resistance analysis Whipsaw Risk: During consolidation, EMAs can cross back and forth frequently (especially on 15m timeframe) Lag: EMAs are lagging indicators; crossovers occur after the move has already begun False Signals: More common during sideways markets; work best in trending environments Symbol Limits: TradingView has limits on request.security() calls; this scanner uses 40 calls (10 symbols × 4 timeframes) Performance: On lower-end devices, scanning 10 symbols across 4 timeframes may cause slight delays in chart updates Best Practices: Start with 5 symbols and 2 timeframes, then expand as you get comfortable Use in conjunction with a main chart for price context Don't trade every signal—filter for high-quality setups Backtest your favorite EMA pairs on your symbols to understand their reliability Adjust the time filter to exclude lunch hours if your market has low midday volume Check the footer statistics—if you're getting 50+ signals per day, tighten your time filter or reduce symbols Technical Notes: Uses lookahead=barmerge.lookahead_off to prevent future data leakage Signals are stored in arrays and sorted by timestamp (newest first) Automatic daily reset clears old signals to prevent memory buildup Table dynamically resizes based on signal count All times displayed in Europe/Istanbul timezone (configurable in code)
Indicador Pine Script®
por TraderDemircan_
ZS Master Vision Pro - Advanced Multi-Timeframe Trading SystemZS MASTER VISION PRO - PROFESSIONAL TRADING SUITE Created by Zakaria Safri A comprehensive, all-in-one trading system combining multiple proven technical analysis methods into a single, powerful indicator. Designed for traders who demand precision, clarity, and actionable signals across all timeframes. KEY FEATURES CORE TREND ALGORITHM Adaptive ATR-based trend detection with dynamic support and resistance zones. Features Type A and Type B signal modes for different trading styles, strong signal detection in key reversal zones, and optional EMA source smoothing for noise reduction. MULTI-LAYER EMA CLOUD SYSTEM Five customizable EMA cloud layers for multi-timeframe analysis with theme-adaptive color coding across five professional themes. Optional line display for detailed MA tracking with configurable periods from scalping to position trading. WAVE TREND OSCILLATOR Advanced momentum oscillator with channel-based calculations featuring smart reversal detection at extreme overbought and oversold levels. Includes directional strength confirmation and customizable sensitivity with adjustable reaction periods. DIVERGENCE SCANNER Detects four types of divergence automatically: - Regular Bullish: Price making lower lows while oscillator making higher lows - Regular Bearish: Price making higher highs while oscillator making lower highs - Hidden Bullish: Trend continuation signals in uptrends - Hidden Bearish: Trend continuation signals in downtrends Automatic fractal-based detection with clear visual labels on chart. MARKET BIAS INDICATOR Heikin Ashi-based trend strength analysis with real-time bias calculation showing Bullish or Bearish combined with Strong or Weak conditions. Smoothed for cleaner signals and perfect for trend confirmation. MOMENTUM SYSTEM Proprietary momentum calculation using adaptive smoothing with growing and falling state detection. Normalized values for consistent interpretation and responsive to rapid market changes. DYNAMIC SUPPORT AND RESISTANCE Automatic pivot-based support and resistance level detection with adjustable left and right bar lookback. Non-repainting levels with visual clarity through color-coded lines. LIVE INFORMATION DASHBOARD Real-time market analysis panel displaying current trend direction, market bias based on Heikin Ashi, Wave Trend status and value, and momentum trend with state. Customizable display options with theme-adaptive colors. VISUAL CUSTOMIZATION FIVE PROFESSIONAL COLOR THEMES: Pro - Modern green and red color scheme (default) Classic - Traditional teal and red combination Cyberpunk - Neon cyan and magenta contrast Ocean - Blue and orange contrast Sunset - Gold and red warmth SIGNAL STYLES: Labels with emoji indicators (BUY with rocket, SELL with bear, STRONG with lightning) Arrows for clean minimal appearance Triangles for classic approach DISPLAY OPTIONS: Color-coded candles following trend direction Trend background highlighting for instant trend recognition Optional EMA line display for detailed analysis Adjustable transparency levels for personal preference SMART ALERTS Pre-configured alert conditions for all major signals: Buy signals for standard entry opportunities Sell signals for standard exit or short opportunities Strong buy signals for high-confidence long entries Strong sell signals for high-confidence short entries Bullish divergence detection alerts Bearish divergence detection alerts Alert messages automatically include ticker symbol, current price, and specific signal type for quick decision making. HOW TO USE FOR TREND TRADERS: Enable EMA Clouds with focus on Cloud 5 featuring 50 and 200 period moving averages. Wait for trend background color change to confirm direction. Enter on STRONG signals aligned with higher timeframe trend direction. Use support and resistance levels for strategic exits. FOR SWING TRADERS: Enable Wave Trend Oscillator information display. Look for oversold and overbought reversal setups. Confirm potential reversals with divergence scanner. Enter on smart reversal signals with proper risk management. FOR SCALPERS: Use Type B signal mode for more frequent trading signals. Enable Cloud 1 with 5 and 13 periods for quick trend confirmation. Focus on momentum growing and falling states for entry timing. Take quick entries on regular buy and sell signals. FOR POSITION TRADERS: Use Type A mode with higher ATR multiplier set to 3.0 or above. Enable only Cloud 5 with 50 and 200 periods for major trend confirmation. Only take STRONG signals for highest probability setups. Hold positions through minor pullbacks and noise. RECOMMENDED SETTINGS STOCKS ON DAILY TIMEFRAME: Trend Period: 180 ATR Period: 155 ATR Multiplier: 2.1 Signal Mode: Type A FOREX ON HOURLY AND 4-HOUR TIMEFRAMES: Trend Period: 150 ATR Period: 120 ATR Multiplier: 2.5 Signal Mode: Type A CRYPTOCURRENCY ON 15-MINUTE AND 1-HOUR TIMEFRAMES: Trend Period: 100 ATR Period: 80 ATR Multiplier: 3.0 Signal Mode: Type B SCALPING ON 1-MINUTE AND 5-MINUTE TIMEFRAMES: Trend Period: 50 ATR Period: 40 ATR Multiplier: 2.0 Signal Mode: Type B WHAT IS INCLUDED Trend Analysis using ATR-based adaptive algorithm Five EMA Cloud Layers for multi-timeframe confluence Wave Trend Oscillator for momentum and reversal detection Divergence Scanner detecting four types of divergence Market Bias using Heikin Ashi-based trend strength Momentum System with advanced momentum tracking Support and Resistance Levels with automatic pivot detection Live Dashboard showing real-time market analysis Smart Alerts featuring six pre-configured alert types Five Color Themes offering professional visual options TECHNICAL DETAILS CALCULATION METHODS: Average True Range (ATR) for volatility adaptation Exponential Moving Average (EMA) and Simple Moving Average (SMA) for trend smoothing Wave Trend channel oscillator for momentum analysis Fractal-based divergence detection algorithm Heikin Ashi transformation for bias calculation Logarithmic momentum calculation for precision PERFORMANCE CHARACTERISTICS: Optimized for maximum speed and efficiency No repainting signals ensuring reliability Works on all timeframes from 1 minute to monthly Compatible with all instruments including stocks, forex, crypto, and futures RISK DISCLAIMER This indicator is a technical analysis tool and should not be used as the sole basis for trading decisions. Always use proper risk management and never risk more than you can afford to lose. Combine with other analysis methods and practice on demo accounts first. Past performance does not guarantee future results. Trading carries substantial risk and is not suitable for all investors. SUPPORT AND UPDATES Regular updates and continuous improvements Based on proven technical analysis principles Developed following Pine Coders best practices and standards Clean, well-documented, and optimized code structure WHY CHOOSE ZS MASTER VISION PRO All-in-one solution eliminating the need for multiple indicators Highly customizable to adapt to your specific trading style Professional grade analysis with institutional-quality standards Clean interface that is not cluttered or confusing Works everywhere across all markets and all timeframes Smart signals filtered for quality over quantity Beautiful design featuring five professional color themes Active development with regular improvements and updates Transform your trading with ZS Master Vision Pro today. Version 2.0 | Created by Zakaria Safri | Pine Script Version 5
Indicador Pine Script®
por zakariasafri47
Global Risk Terminal – Multi-Asset Macro Sentiment IndicatorDescription: The Global Risk Terminal is a sophisticated macro sentiment indicator that synthesizes signals from three key cross-asset relationships to produce a single, actionable risk appetite score. It is designed to help traders and investors identify whether global markets are in a risk-on (growth-seeking) or risk-off (defensive) regime. The indicator analyzes the behavior of commodities, equities, bonds, and currencies to generate a comprehensive view of market conditions. Indicator Output: The Global Risk Terminal produces a normalized risk score ranging from -1 to +1: Positive values indicate risk-on conditions (growth assets favored) Negative values indicate risk-off conditions (safe-haven assets favored) Core Components: Growth Pulse (Copper to Gold Ratio, HG/GC) Purpose: Measures investor preference for industrial growth versus safe-haven assets. Interpretation: Rising ratio → Copper outperforming gold → Risk-on environment Falling ratio → Gold outperforming copper → Risk-off environment Flat ratio → Transitional market phase Technical Implementation: Dual moving average slope method (fast MA default 20, slow MA default 40). Positive slope = +1, negative slope = -1, flat slope = 0 Equity Rotation (Russell 2000 to S&P 500 Ratio, RTY/ES) Purpose: Tracks rotation between small-cap and large-cap equities, revealing market risk appetite. Interpretation: Rising ratio → Small-caps outperforming → Strong risk-on Falling ratio → Large-caps outperforming → Defensive positioning Technical Implementation: Dual moving average slope method (same as Growth Pulse) Flow Gauge (10-Year Treasury to US Dollar Index, ZN/DXY) Purpose: Captures liquidity conditions and cross-asset capital flows. Interpretation: Rising ratio → Treasury prices rising or USD weakening → Liquidity expansion, risk-on environment Falling ratio → Treasury prices falling or USD strengthening → Liquidity contraction, risk-off environment Technical Implementation: Dual moving average slope method Composite Risk Score Calculation: Analyze each component for trend using dual moving averages Assign signal values: +1 (risk-on), -1 (risk-off), 0 (neutral) Average the three signals: Risk Score = (Growth Pulse + Equity Rotation + Flow Gauge) / 3 Optional smoothing with exponential moving average (default 3 periods) to reduce noise Interpreting the Risk Score: +0.66 to +1.0: Full risk-on – favor cyclical sectors, small-caps, growth strategies +0.33 to +0.66: Moderate risk-on – mostly bullish environment, watch for fading momentum -0.33 to +0.33: Neutral/transition – markets in flux, signals mixed, exercise caution -0.66 to -0.33: Cautious risk-off – favor defensive sectors, reduce high-beta exposure -1.0 to -0.66: Full risk-off – strong defensive positioning, prioritize safe-haven assets How to Use the Global Risk Terminal to Frame Trades: Aligning Trades with Market Regime Risk-On (+0.33 and above): Look for buying opportunities in cyclical stocks, high-beta equities, commodities, and emerging markets. Use long entries for swing trades or intraday positions, following confirmed price action. Risk-Off (-0.33 and below): Shift focus to defensive sectors, large-cap quality stocks, U.S. Treasuries, and safe-haven currencies. Prefer short entries or reduced exposure in risky assets. Entry and Exit Framing Use the risk score as a macro filter before executing trades: Example: The risk score is +0.7 (strong risk-on). Prefer long positions in equities or commodities that are showing bullish confirmation on your regular chart. Conversely, if the risk score is -0.7 (strong risk-off), avoid aggressive longs and consider short or defensive trades. Watch for threshold crossings (+/-0.33, +/-0.66) as potential inflection points for adjusting position size, stop-loss levels, or sector rotation. Confirming Trade Decisions Combine the Global Risk Terminal with price action, volume, and trend indicators: If equities rally but the risk score is declining, this may indicate a fragile rally driven by few leaders—trade cautiously. If equities fall but the risk score is rising, consider counter-trend entries or buying dips. Risk Management and Position Sizing Strong alignment across components → increase position size and hold with wider stops Mixed or neutral signals → reduce exposure, tighten stops, or avoid new trades Defensive regimes → rotate into stable, low-volatility assets and increase cash buffer Framing Trades Across Timeframes Use the indicator as a strategic guide rather than a precise timing tool. Even without the MTF table: Daily trend alignment → Guide swing trade bias Shorter timeframe price action → Refine entry points and stop placement Example: Daily chart shows +0.6 risk score → identify high-probability long setups using intraday technical patterns (breakouts, trend continuation). Sector and Asset Rotation Risk-On: Focus on cyclical sectors (financials, industrials, materials, energy), small-caps, high-beta instruments Risk-Off: Focus on defensive sectors (utilities, consumer staples, healthcare), large-caps, safe-haven instruments Alert Integration Set alerts on the risk score to notify you when markets move from neutral to risk-on or risk-off regimes. Use these alerts to plan entries, exits, or portfolio adjustments in advance. Customization Options: Moving Average Length (5–100): Adjust sensitivity of trend detection Score Smoothing (1–10): Reduce noise or see raw risk score Visual Themes: Six preset themes (Cyber, Ocean, Sunset, Monochrome, Matrix, Custom) Display Options: Show or hide component dashboards, main header, risk level lines, gradient fill, and component signals Label Size: Tiny, Small, Normal, Large Alert Conditions: Risk score crosses above +0.66 → Strong risk-on Risk score crosses below -0.66 → Strong risk-off Risk score crosses zero → Neutral line Risk score crosses above +0.33 → Moderate risk-on Risk score crosses below -0.33 → Moderate risk-off Data Sources: HG1! – Copper Futures (COMEX) GC1! – Gold Futures (COMEX) RTY1! – Russell 2000 E-mini Futures (CME) ES1! – S&P 500 E-mini Futures (CME) ZN1! – 10-Year U.S. Treasury Note Futures (CBOT) DXY – U.S. Dollar Index (ICE) Notes and Limitations: Works best during clear macro regimes and aligned trends Use with price action, volume, and other technical tools Not a standalone trading system; serves as a macro context filter Equal weighting assumes all three components are equally important, but market conditions may vary Past performance does not guarantee future results Conclusion: The Global Risk Terminal consolidates complex cross-asset signals into a simple, actionable score that informs market regime, portfolio positioning, sector rotation, and trading decisions. Its user-friendly layout and extensive customization options make it suitable for traders of all experience levels seeking macro-driven insights. By framing trades around risk score thresholds and combining macro context with tactical execution, traders can identify higher-probability opportunities and optimize position sizing, entries, and exits across a wide range of market conditions.
Indicador Pine Script®
por joeljohnrussell
Multiple EMA/SMA v6This indicator plots up to eight Exponential Moving Averages (EMAs) and six Simple Moving Averages (SMAs) on the same chart. Each moving average can be individually customized or disabled by setting its length to 0. It’s designed for traders who want to visually compare multiple EMAs and SMAs with consistent styling and color-coding. Key features: Displays up to 14 customizable EMAs/SMAs. Adjustable line width and source (e.g., close, open, hlc3). Simple and performance-optimized structure. Clean color scheme for quick trend identification. Usage: Set any moving average length to 0 to hide it, or adjust lengths and colors to match your strategy. Ideal for identifying short-, mid-, and long-term trend alignments.
Indicador Pine Script®
por WolleTradet